package com.ocean.web.controller.product;
/* 这是 netCDF 包的一部分。
   版权所有 2006 University Corporation for Atmospheric Research/Unidata。
   有关使用条件，请参阅版权文件。

   这是一个简单的例子，它读取了一个小型虚拟数组，它是
   由simple_xy_wr.java撰写。 这是为了说明用法
   的 netCDF Java API。

   此示例演示 netCDF Java API。

   netCDF Java API 的完整文档可在以下位置找到：
   http://www.unidata.ucar.edu/software/netcdf-java/
*/


import ucar.ma2.Array;
import ucar.nc2.Variable;
import ucar.nc2.dataset.NetcdfDataset;
import ucar.nc2.dataset.NetcdfDatasets;
import javax.imageio.stream.ImageOutputStream;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.List;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Sfc_pres_temp_wr {

   /* public static void main(String args[]) throws IOException {
        String fileName = "E:\\11.nc";
        NetcdfFile dataFile = null;
        try {
            NetcdfFile ncFile = NetcdfFile.open(fileName); //获取源文件
            Variable v = ncFile.findVariable("u");
            Variable lon = ncFile.findVariable("lon");
            Variable lat = ncFile.findVariable("lat");
            Variable time = ncFile.findVariable("time");
            Array read = v.read();
            System.out.println(lon.read().getSize());
            System.out.println(lat.read().getSize());
            System.out.println(time.read().getSize());


        } catch (java.io.IOException e) {
            e.printStackTrace();
            return;

        } finally {
            if (dataFile != null)
                try {
                    dataFile.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
        }
        System.out.println("*** SUCCESS reading example file ");


    }*/



/* 这是 netCDF 包的一部分。
 版权所有 2006 University Corporation for Atmospheric Research/Unidata。
 有关使用条件，请参阅版权文件。
 此示例记录了一些表面压力和温度。 是的
 旨在说明 netCDF Java API 的使用。 同伴
 程序 sfc_pres_temp_rd.java 演示如何读取 netCDF 数据文件
 由此程序创建。

 此示例演示 netCDF Java API。

 netCDF Java API 的完整文档可在以下位置找到：
   http://www.unidata.ucar.edu/software/thredds/current/netcdf-java/documentation.htm

 示例由 Peter Jansen 提供
 */
     /*   public static void main(String args[]) throws Exception {
            final int NLAT = 6;
            final int NLON = 12;
            final float SAMPLE_PRESSURE = 900.0f;
            final float SAMPLE_TEMP = 9.0f;
            final float START_LAT = 25.0f;
            final float START_LON = -125.0f;

            // 创建文件.
            String filename = "sfc_pres_temp.nc";
            NetcdfFileWriter dataFile = null;

            try {
                // 使用给定的文件名创建新的 netcdf-3 文件
                dataFile = NetcdfFileWriter.createNew(NetcdfFileWriter.Version.netcdf3, filename);

                // 除了纬度和经度维度外，我们还将
                // 还创建纬度和经度 netCDF 变量，这些变量将
                // 保持实际的纬度和经度。因为他们持有数据
                // 关于坐标系，这些坐标系的 netCDF 术语为：
                // “坐标变量。”
                Dimension latDim = dataFile.addDimension(null, "latitude", NLAT);
                Dimension lonDim = dataFile.addDimension(null, "longitude", NLON);
                List<Dimension> dims = new ArrayList<Dimension>();
                dims.add(latDim);
                dims.add(lonDim);

                Variable vlat = dataFile.addVariable(null, "latitude", DataType.FLOAT, "latitude");
                Variable vlon = dataFile.addVariable(null, "longitude", DataType.FLOAT, "longitude");

                Variable vPres = dataFile.addVariable(null, "pressure", DataType.FLOAT, dims);
                Variable vTemp = dataFile.addVariable(null, "temperature", DataType.FLOAT, dims);

                // 定义坐标变量的单位属性。这附加了一个
                // text 属性添加到每个坐标变量中，其中包含
                // 单位。

                vlat.addAttribute(new Attribute("units", "degrees_east"));
                vlon.addAttribute(new Attribute("units", "degrees_north"));

                // 定义变量的单位属性。
                vPres.addAttribute(new Attribute("units", "hPa"));
                vTemp.addAttribute(new Attribute("units", "celsius"));

                // 写入坐标变量数据。这将把纬度
                // 并将数据网格的经度放入 netCDF 文件中。
                dataFile.create();

                Array dataLat = Array.factory(DataType.FLOAT, new int[]{NLAT});
                Array dataLon = Array.factory(DataType.FLOAT, new int[]{NLON});

                // 创建一些假装数据。如果这不是一个示例程序，我们
                // 会有一些真实的数据要写，例如，模型
                // 输出。
                int i, j;

                for (i = 0; i < latDim.getLength(); i++) {
                    dataLat.setFloat(i, START_LAT + 5.f * i);
                }

                for (j = 0; j < lonDim.getLength(); j++) {
                    dataLon.setFloat(j, START_LON + 5.f * j);
                }

                dataFile.write(vlat, dataLat);
                dataFile.write(vlon, dataLon);

                // 创建假装数据。这将写出我们的表面压力和
                // 表面温度数据。

                int[] iDim = new int[]{latDim.getLength(), lonDim.getLength()};
                Array dataTemp = Array.factory(DataType.FLOAT, iDim);
                Array dataPres = Array.factory(DataType.FLOAT, iDim);

                Index2D idx = new Index2D(iDim);

                for (i = 0; i < latDim.getLength(); i++) {
                    for (j = 0; j < lonDim.getLength(); j++) {
                        idx.set(i, j);
                        dataTemp.setFloat(idx, SAMPLE_TEMP + .25f * (j * NLAT + i));
                        dataPres.setFloat(idx, SAMPLE_PRESSURE + (j * NLAT + i));
                    }
                }

                dataFile.write(vPres, dataPres);
                dataFile.write(vTemp, dataTemp);
            } catch (IOException e) {
                e.printStackTrace();

            } catch (InvalidRangeException e) {
                e.printStackTrace();

            } finally {
                if (null != dataFile) {
                    try {
                        dataFile.close();
                    } catch (IOException ioe) {
                        ioe.printStackTrace();
                    }
                }
            }
            System.out.println("*** SUCCESS 编写示例文件 sfc_pres_temp.nc!");
        }*/



    /* 这是 netCDF 包的一部分。
       版权所有 2006 University Corporation for Atmospheric Research/Unidata。
     *
        有关使用条件，请参阅版权文件。

      这是一个示例，其中读取了一些表面压力和
      温度。生成此程序读取的数据文件
      同伴计划sfc_pres_temp_wr.java。它旨在
      说明如何使用 netCDF Java API。

      此示例演示 netCDF Java API。

      netCDF Java API 的完整文档可在以下位置找到：
       http://www.unidata.ucar.edu/software/netcdf-java/
     */
 /*   public static void main(String args[]) throws Exception {
        // 打开文件并检查以确保其有效。
        String filename = "E:\\11.nc";
        String imageOutputPath = "E:\\image.png"; // 图像输出路径
        NetcdfFile dataFile = null;

        try {
            dataFile = NetcdfFile.open(filename, null);

        } catch (IOException e) {
            System.out.println(" fail = " + e);
            e.printStackTrace();
        }
        System.out.println("*** SUCCESS reading example file sfc_pres_temp.nc!");
    }

    private static int findIndexOf(float[] arr, float value) {
        int index = Arrays.binarySearch(arr, value);
        return (index >= 0) ? index : -index - 1;
    }

    private static Map<String,String> getMapdata(double lon, double lat, double v){
        Map map = new HashMap();
        map.put("lon",lon);
        map.put("lat",lat);
        map.put("data",v);
        return map;
    }*/



 /*   public static void main(String[] args) {
        try {
            cjnc1();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }*/
  /*  public static void cjnc1() throws IOException, InvalidRangeException {
        double minLat = 30.0; // 区域最小纬度
        double maxLat = 40.0; // 区域最大纬度
        double minLon = 120.0; // 区域最小经度
        double maxLon = 110.0; // 区域最大经度

        String filename = "E:\\testL0.nc";
        NetcdfDataset dataset = NetcdfDatasets.openDataset(filename);
        Variable lon = dataset.findVariable("lon");
        Variable lat = dataset.findVariable("lat");
        Variable time = dataset.findVariable("time");
        *//*Variable u = dataset.findVariable("u");
        Variable v = dataset.findVariable("v");*//*
        Variable sst = dataset.findVariable("sst");


        String pathAndFilenameStr = "E:\\out22.nc";
        NetcdfFormatWriter.Builder builder = NetcdfFormatWriter.createNewNetcdf3(pathAndFilenameStr);
        // 2) 定义维度、变量和属性。
// 请注意，使用 NetcdfFileWriter.addUnlimitedDimension（） 添加记录维度。
        long size1 = lon.read().getSize();
        builder.addDimension("lon", (int) lon.read("0:20").getSize());
        long size2 = lat.read().getSize();
        builder.addDimension("lat", (int) lat.read("0:10").getSize());
        long size3 = time.read().getSize();
        builder.addDimension("time", (int) time.read("0:10").getSize());

// 3) 定义变量
        builder.addVariable("lon", DataType.FLOAT, "lon")
                .addAttribute(lon.findAttribute("units"));
        builder.addVariable("lat", DataType.FLOAT, "lat")
                .addAttribute(lat.findAttribute("units"));
        builder.addVariable("time", DataType.FLOAT, "time")
                .addAttribute(time.findAttribute("units"));
        *//*builder.addVariable("u", DataType.FLOAT, "time lat lon")
                .addAttribute(u.findAttribute("long_name"))
                .addAttribute(u.findAttribute("units"));
        builder.addVariable("v", DataType.FLOAT, "time lat lon")
                .addAttribute(v.findAttribute("long_name"))
                .addAttribute(v.findAttribute("units"));*//*
        builder.addVariable("v", DataType.FLOAT, "time lat lon")
                .addAttribute(sst.findAttribute("long_name"))
                .addAttribute(sst.findAttribute("units"));


// 4) 创建文件
        try (NetcdfFormatWriter writer = builder.build()) {
            // 5)写入非记录 Variables
            int[] origin = new int[] {0, 0, 0};
            int[] size = new int[] {100, 100, 50};
            writer.write("lon", lon.read("0:20"));
            writer.write("lat", lat.read("0:10"));
            writer.write("time", time.read("0:10"));
          *//*  writer.write("v", v.read("0,10:20,0:10"));
            writer.write("u", u.read("0,10:20,0:10"));*//*
            writer.write("v", sst.read("1,5:10,1:1"));//参数应该是（时间,开始经纬度,结束经纬度）

        } catch (IOException e) {
            e.printStackTrace();
        } catch (InvalidRangeException e) {
            throw new RuntimeException(e);
        }
        }
    public static void cjnc(){
        String pathAndFilenameStr = "E:\\out.nc";
        NetcdfFormatWriter.Builder builder = NetcdfFormatWriter.createNewNetcdf3(pathAndFilenameStr);
        // 2) 定义维度、变量和属性。
// 请注意，使用 NetcdfFileWriter.addUnlimitedDimension（） 添加记录维度。
        ucar.nc2.Dimension latDim = builder.addDimension("lat", 3);
        ucar.nc2.Dimension lonDim = builder.addDimension("lon", 4);
        Dimension timeDim = builder.addUnlimitedDimension("time");

// 3) 定义变量
        builder.addVariable("lat", DataType.FLOAT, "lat")
                .addAttribute(new Attribute("units", "degrees_north"));
        builder.addVariable("lon", DataType.FLOAT, "lon")
                .addAttribute(new Attribute("units", "degrees_east"));
        builder.addVariable("rh", DataType.INT, "time lat lon")
                .addAttribute(new Attribute("long_name", "relative humidity"))
                .addAttribute(new Attribute("units", "percent"));
        builder.addVariable("T", DataType.DOUBLE, "time lat lon")
                .addAttribute(new Attribute("long_name", "surface temperature"))
                .addAttribute(new Attribute("units", "degC"));
        builder.addVariable("time", DataType.INT, "time")
                .addAttribute(new Attribute("units", "hours since 1990-01-01"));

// 4) 创建文件
        try (NetcdfFormatWriter writer = builder.build()) {
            // 5)写入非记录 Variables
            writer.write("lat", Array.makeFromJavaArray(new float[] {41, 40, 39}, false));
            writer.write("lon", Array.makeFromJavaArray(new float[] {-109, -107, -105, -103}, false));

            // 6) 写入记录 Variables （无限尺寸）
            // 创建数组以保存数据。
            // 请注意，外部维度的形状为 1，因为我们一次只写入一条记录。
            ArrayInt rhData = new ArrayInt.D3(1, latDim.getLength(), lonDim.getLength(), true);
            ArrayDouble.D3 tempData = new ArrayDouble.D3(1, latDim.getLength(), lonDim.getLength());
            Array timeData = Array.factory(DataType.INT, new int[] {1});
            Index ima = rhData.getIndex();

            int[] origin = new int[] {0, 0, 0};
            int[] time_origin = new int[] {0};

            // 7) 循环访问 unlimited （record） 维度。每个循环将写入一条记录。
            for (int timeIdx = 0; timeIdx < 10; timeIdx++) {
                // 8) 设置此记录的数据，使用三种不同的方式填充数据数组。
                // 在所有情况下，第一个维度的 index = 0。

                // 8.1) Array.setInt（Index ima， int value） ： timeData.getIndex（） 返回初始化为零的 Index。
                timeData.setInt(timeData.getIndex(), timeIdx * 12);

                for (int latIdx = 0; latIdx < latDim.getLength(); latIdx++) {
                    for (int lonIdx = 0; lonIdx < lonDim.getLength(); lonIdx++) {
                        // 8.2) Array.setInt（索引 ima， int value） ： ima.set（0， lat， lon） 显式设置维度索引
                        rhData.setInt(ima.set(0, latIdx, lonIdx), timeIdx * latIdx * lonIdx);
                        // 8.3) ArrayDouble.D3.set（int i， int j， int k， double value）：
                        // 通过使用特定于类型和排名的 Array 类 （ArrayDouble.D3），我们不需要使用 Index。
                        tempData.set(0, latIdx, lonIdx, timeIdx * latIdx * lonIdx / 3.14159);
                    }
                }

                // 9) 将 origin 设置为当前记录编号。其他维度的原点为 0。
                time_origin[0] = timeIdx;
                origin[0] = timeIdx;
                // 10) 在指定的源处写入数据。
                writer.write("rh", origin, rhData);
                writer.write("T", origin, tempData);
                writer.write("time", time_origin, timeData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InvalidRangeException e) {
            throw new RuntimeException(e);
        }

    }*/

}